home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1996 September / MACPOWER-1996-09.ISO.7z / MACPOWER-1996-09.ISO / 第２特集：プラグイン大集合 / PIC2 Save / p2savehi.c < prev    next >
Text File  |  1995-01-16  |  13KB  |  732 lines
  1. /*
  2.  *    PIC2 高圧縮/ベタフォーマットの展開 by やなぎさわ
  3.  *
  4.  */
  5.  
  6. #include "pic2.h"
  7.  
  8. /* 現在のP2の中の変数のコピー (^^; */
  9.  
  10. static ushort bit_buf;
  11. static short n_bit_buf;
  12. static long xw;
  13. static long ymax;
  14. static uchar *fbufp;
  15. static long n_fbuf;
  16. static long len;
  17. static P2 *p2;
  18.  
  19. static pix *vram_prev;
  20. static pix *vram_now;
  21. static pix *vram_next;
  22. static schar *flag_now;
  23. static schar *flag_next;
  24.  
  25. static pix  (_HUGE_ * cache)[N_CACHE];
  26. static ushort *cache_pos;
  27. static ushort cache8_pos;
  28. static short ynow;
  29. static long chain_pos;
  30. static char *chain_buff;
  31.  
  32. static pix (*write_color)( pix x);
  33.  
  34. /* エラー時の脱出用 */
  35. static jmp_buf jmp_env;
  36.  
  37. /*
  38.  * １バイト　ファイルに書き出し
  39.  */
  40. static void
  41. write_byte( uchar a)
  42. {
  43.     *fbufp++ = a;
  44.     if ( --n_fbuf == 0) {
  45.         fbufp = p2->fbuf;
  46.         n_fbuf = N_FBUF;
  47.         if ( write_file( p2, fbufp, N_FBUF) != N_FBUF) {
  48.             p2errno = p2->errno = dskFulErr;//ENOSPC;
  49.             longjmp( jmp_env, 1);
  50.         }
  51.     }
  52.     n_bit_buf = 8;
  53. }
  54.  
  55. /*
  56.  *  ビットのバッファのフラッシュ
  57.  */
  58. static void
  59. bit_buf_flush( void)
  60. {
  61.     if ( n_bit_buf > 0) {
  62.         bit_buf <<= n_bit_buf;
  63.         write_byte(bit_buf);
  64.     }
  65. }
  66.  
  67. /*
  68.  * ファイルバッファのフラッシュ
  69.  */
  70. static void
  71. fbuf_flush( void)
  72. {
  73.     long n;
  74.  
  75.     bit_buf_flush();
  76.     write_byte( 0);
  77.     n = N_FBUF - n_fbuf;
  78.     if ( write_file( p2, p2->fbuf, n) != n) {
  79.         longjmp( jmp_env, 1);
  80.     }
  81. }
  82.  
  83. /* size ビット n の下位から書き出します */
  84. static const ushort    bit_mask[] = {
  85.     0,
  86.     0x0001,
  87.     0x0003,
  88.     0x0007,
  89.     0x000f,
  90.  
  91.     0x001f,
  92.     0x003f,
  93.     0x007f,
  94.     0x00ff,
  95.  
  96.     0x01ff,
  97.     0x03ff,
  98.     0x07ff,
  99.     0x0fff,
  100.  
  101.     0x1fff,
  102.     0x3fff,
  103.     0x7fff,
  104.     0xffff,
  105. };
  106.  
  107.  
  108. /*
  109.  * 'size'bit nをかき出す
  110.  */
  111. static void
  112. bit_write( long size, long n)
  113. {
  114.     while ( size >= n_bit_buf) {
  115.         size -= n_bit_buf;
  116.         bit_buf = ( bit_buf << n_bit_buf)
  117.             + (bit_mask[n_bit_buf] & (n >> size));
  118.         write_byte( bit_buf);
  119.     }
  120.     if ( size > 0) {
  121.         bit_buf = ( bit_buf << size) + (bit_mask[size] & n);
  122.         n_bit_buf -= size;
  123.     }
  124. }
  125.  
  126. static const unsigned short len_data[8][2]= {
  127.         1, 0,
  128.         1, 0,
  129.         3, 4,
  130.         3, 5,
  131.         5, 24,
  132.         5, 25,
  133.         5, 26,
  134.         5, 27,
  135. };
  136.  
  137. /*
  138.  * 長さ書きだし
  139.  */
  140. static void
  141. write_length( long n)
  142. {
  143.     long    a;
  144.     long    b;
  145.  
  146.     n++;
  147.     if ( n < 8) {
  148.         bit_write( len_data[n][0], len_data[n][1]);
  149.     } else {
  150.         a = 0;
  151.         b = 2;
  152.         while (n > b - 1) {
  153.             a = a + 1;
  154.             b = b * 2;
  155.         }
  156.         bit_write( a + 1, 0xfffffffe);
  157.         if ( a > 0) bit_write(a, n - b / 2);
  158.     }
  159. }
  160.  
  161.  
  162. /*
  163.  * 連鎖の圧縮
  164.  */
  165. static void
  166. press_chain( long x)
  167. {
  168.     pix cc = vram_now[x ];
  169.  
  170.     if ( ynow - 1 == ymax) {
  171.         bit_write( 1, 0);
  172.         return;
  173.     }
  174.  
  175.     if ( flag_next[ x] == 1 && vram_next[ x] == cc) {
  176.         flag_next[ x] = -1;
  177.         bit_write( 2, 3);
  178.     } else if ( flag_next[ x - 1] == 1 && vram_next[ x - 1] == cc) {
  179.         flag_next[ x - 1] = -1;
  180.         bit_write( 4, 11);
  181.     } else if ( flag_next[ x + 1] == 1 && vram_next[ x + 1] == cc) {
  182.         flag_next[ x + 1] = -1;
  183.         bit_write( 4, 9);
  184.     } else if ( flag_next[ x - 2] == 1 && vram_next[ x - 2] == cc) {
  185.         flag_next[ x - 2] = -1;
  186.         bit_write( 4, 10);
  187.     } else if ( (flag_next[ x + 2] == 1 && vram_next[ x + 2] == cc)
  188.         && !( flag_now[ x + 2] != 0 &&  vram_now[ x + 2] == cc)
  189.         ) {
  190.  
  191.         flag_next[ x + 2] = -1;
  192.         bit_write( 4, 8);
  193.     } else {
  194.         bit_write( 1, 0);
  195.     }
  196. }
  197.  
  198.  
  199. /*
  200.  * 連鎖の圧縮(ただし結果はバッファに入る)
  201.  */
  202. static void
  203. press_chain2( long x)
  204. {
  205.     pix cc = vram_now[x ];
  206.  
  207.     if ( ynow - 1 == ymax) {
  208.         chain_buff[ chain_pos++] = 0;
  209.         return;
  210.     }
  211.  
  212.     if ( flag_next[ x] == 1 && vram_next[ x] == cc) {
  213.         flag_next[ x] = -1;
  214.         chain_buff[ chain_pos++] = 1;
  215.     } else if ( flag_next[ x - 1] == 1 && vram_next[ x - 1] == cc) {
  216.         flag_next[ x - 1] = -1;
  217.         chain_buff[ chain_pos++] = 2;
  218.     } else if ( flag_next[ x + 1] == 1 && vram_next[ x + 1] == cc) {
  219.         flag_next[ x + 1] = -1;
  220.         chain_buff[ chain_pos++] = 3;
  221.     } else if ( flag_next[ x - 2] == 1 && vram_next[ x - 2] == cc) {
  222.         flag_next[ x - 2] = -1;
  223.         chain_buff[ chain_pos++] = 4;
  224.     } else if ( (flag_next[ x + 2] == 1 && vram_next[ x + 2] == cc)
  225.         && !( flag_now[ x + 2] != 0 &&  vram_now[ x + 2] == cc)
  226.         ) {
  227.  
  228.         flag_next[ x + 2] = -1;
  229.         chain_buff[ chain_pos++] = 5;
  230.     } else {
  231.         chain_buff[ chain_pos++] = 0;
  232.     }
  233. }
  234.  
  235. /*
  236.  * 連鎖バッファのフラッシュ
  237.  */
  238. static void
  239. chain_flush( void)
  240. {
  241.     long i;
  242.  
  243.     for ( i = 0; i < chain_pos; i++){
  244.         switch ( chain_buff[i]) {
  245.         case 0:    bit_write( 1, 0);    break;
  246.         case 1:    bit_write( 2, 3);    break;
  247.         case 2:    bit_write( 4, 11);    break;
  248.         case 3:    bit_write( 4, 9);    break;
  249.         case 4:    bit_write( 4, 10);    break;
  250.         case 5:    bit_write( 4, 8);    break;
  251.         }
  252.     }
  253.     chain_pos = 0;
  254. }
  255.  
  256. /*
  257.  * 15bit色の書き出し
  258.  */
  259. static void
  260. write_color15( pix x)
  261. {
  262.     pix    cc;
  263.     long    j,k,m;
  264.  
  265.     k = vram_now[x-1] >> 8;
  266.     cc = vram_now[ x];
  267.     m = cache_pos[k];
  268.  
  269.     for ( j = 0; j < N_CACHE; j++) {
  270.         if ( cache[k][ ( m + j) & (N_CACHE-1)] == cc) break;
  271.     }
  272.     if ( j == N_CACHE) {
  273.         m = (m - 1) & (N_CACHE-1);
  274.         cache_pos[k] = m;
  275.         cache[k][m] = cc;
  276.  
  277.         bit_write( 1, 0);
  278.         bit_write( 15, cc / 2);
  279.     } else {
  280.         bit_write( 1, 1);
  281.         bit_write( 6, j);
  282.     }
  283. }
  284.  
  285. #if 0
  286. /*
  287.  * 16(8)bit色の書き出し
  288.  */
  289. static void
  290. write_color8( uchar cc)
  291. {
  292.     uchar *cache8 = (uchar *)(cache_pos + 256);
  293.     short i;
  294.     
  295.     for ( i = 0; i < 8; i++) {
  296.         if ( cache8[(i + cache8_pos) & 7] == cc) break;
  297.     }
  298.     if ( i == 8) {
  299.         cache8_pos = (cache8_pos - 1) & 7;
  300.         cache8[ cache8_pos] = cc;
  301.         bit_write( 1, 0);
  302.         bit_write( 8, cc);
  303.     } else {
  304.         bit_write( 1, 1);
  305.         bit_write( 3, i);
  306.     }
  307. }
  308. #endif
  309.  
  310. static void
  311. write_color8( uchar cc)
  312. {
  313.     uchar *cache8 = (uchar *)(cache_pos + 256);
  314.     short i,j;
  315.     
  316.     for ( i = 0; i < 16; i++) {
  317.         if ( cache8[ i] == cc) break;
  318.     }
  319.     for ( j = i; j > 0; j--) {
  320.         cache8[ j] = cache8[ j - 1];
  321.     }
  322.     cache8[0] = cc;
  323.     if ( i == 16) {
  324.         bit_write( 1, 0);
  325.         bit_write( 8, cc);
  326.     } else {
  327.         bit_write( 1, 1);
  328.         bit_write( 4, i);
  329.     }
  330. }
  331.  
  332. #define    N_CACHE8_S    4
  333. #define N_CACHE8    (1<<N_CACHE8_S)
  334.  
  335. #if 0
  336.  
  337. static void
  338. write_color16( pix x)
  339. {
  340.     pix    cc;
  341.     long    j,k,m;
  342.  
  343.     k = vram_now[ x - 1] & 255;
  344.     cc = vram_now[ x];
  345.     m = cache_pos[k];
  346.  
  347.     for ( j = 0; j < N_CACHE8; j++) {
  348.         if ( cache[k][ ( m + j) & (N_CACHE8-1)] == cc) break;
  349.     }
  350.     if ( j == N_CACHE8) {
  351.         m = (m - 1) & (N_CACHE8-1);
  352.         cache_pos[k] = m;
  353.         cache[k][m] = cc;
  354.  
  355.         bit_write( 1, 0);
  356.         write_color8( cc >> 8);
  357.         write_color8( cc & 255);
  358.         
  359.         /* bit_write( 16, cc); */
  360.     } else {
  361.         bit_write( 1, 1);
  362.         bit_write( N_CACHE8_S, j);
  363.     }
  364. }
  365.  
  366. #endif
  367.  
  368. static void
  369. write_color16( pix x)
  370. {
  371.     pix    cc;
  372.     short    j,k,i;
  373.  
  374.     k = vram_now[ x - 1] & 255;
  375.     cc = vram_now[ x];
  376.  
  377.     for ( j = 0; j < N_CACHE8; j++) {
  378.         if ( cache[k][j] == cc) break;
  379.     }
  380.     for ( i = j; i > 0; i--) {
  381.         cache[k][i] = cache[k][i - 1];
  382.     }
  383.     cache[k][0] = cc;
  384.  
  385.     if ( j == N_CACHE8) {
  386.         bit_write( 1, 0);
  387.         write_color8( cc >> 8);
  388.         write_color8( cc & 255);
  389.     } else {
  390.         bit_write( 1, 1);
  391.         bit_write( N_CACHE8_S, j);
  392.     }
  393. }
  394.  
  395.  
  396. /*
  397.  * 24bit色の書き出し
  398.  */
  399.  
  400. static void
  401. write_color24( pix x)
  402. {
  403.     pix    cc;
  404.     long j,k,m;
  405.  
  406.     k = vram_now[ x - 1] >> 16;
  407.     cc = vram_now[ x];
  408.     m = cache_pos[k];
  409.  
  410.     for ( j = 0; j < N_CACHE; j++) {
  411.         if ( cache[k][ ( m + j) & (N_CACHE - 1)] == cc) break;
  412.     }
  413.     if ( j == N_CACHE) {
  414.         m = (m - 1) & (N_CACHE - 1);
  415.         cache_pos[k] = m;
  416.         cache[k][m] = cc;
  417.  
  418.         bit_write( 1, 0);
  419.         bit_write( 24, cc);
  420.     } else {
  421.         bit_write( 1, 1);
  422.         bit_write( 6, j);
  423.     }
  424. }
  425.  
  426. /* 構造体アクセスをケチするため */
  427. static void
  428. para_out( void)
  429. {
  430.     fbufp = p2->fbufp;
  431.     n_fbuf = p2->n_fbuf;
  432.     bit_buf = p2->bit_buf;
  433.     n_bit_buf = p2->n_bit_buf;
  434.     len = p2->aa;
  435.     chain_pos = p2->cc;
  436.     ymax = SHORT2short( p2->blk.y_wid) - 1;
  437.     xw = SHORT2short( p2->blk.x_wid);
  438.     write_color = (pix (*)(pix))p2->func;
  439.     ynow = p2->ynow;
  440.     vram_prev = p2->vram_prev + 4;
  441.     vram_now = p2->vram_now + 4;
  442.     vram_next = p2->vram_next + 4;
  443.     flag_now = p2->flag_now + 4;
  444.     flag_next = p2->flag_next + 4;
  445.     cache8_pos = p2->data;
  446.     cache = (pix (_HUGE_ *)[N_CACHE])p2->cache;
  447.     chain_buff = (char *)p2->mulu_tab;
  448.     cache_pos = p2->cache_pos;
  449. }
  450.  
  451. static void
  452. para_in( void)
  453. {
  454.     void *p;
  455.     
  456.     p2->fbufp = fbufp;
  457.     p2->n_fbuf = n_fbuf;
  458.     p2->bit_buf = bit_buf;
  459.     p2->n_bit_buf = n_bit_buf;
  460.     p2->func = (pix (*)(pix))write_color;
  461.     p2->aa = len;
  462.     p2->cc = chain_pos;
  463.     p2->ynow = ynow;
  464.     p2->data = cache8_pos;
  465.  
  466.     p = p2->vram_prev;
  467.     p2->vram_prev = p2->vram_now;
  468.     p2->vram_now = p2->vram_next;
  469.     p2->vram_next = p;
  470.  
  471.     p = p2->flag_now;
  472.     p2->flag_now = p2->flag_next;
  473.     p2->flag_next = p;
  474. }
  475.  
  476.  
  477. /*
  478.  * 1行圧縮
  479.  */
  480. static void
  481. line_press2( void)
  482. {
  483.     long x,a;
  484.     pix cc;
  485.     
  486.     if ( SHORT2short( p2->header.depth) == 8) {
  487.         cc = vram_now[ xw * 2 - 2];
  488.         cc = cc * 256 + vram_now[ xw * 2 - 1];
  489.     } else {
  490.         cc = vram_now[ xw - 1];    /* ひとつ前の色 */
  491.     }
  492.  
  493.     vram_next[ -1] = cc;
  494.     /* 変化点をマーク */
  495.     for ( x = 0; x < xw; x++) {
  496.         pix c = vram_next[ x];
  497.         if ( cc != c) {
  498.             flag_next[ x] = 1;
  499.             cc = c;
  500.         } else flag_next[ x] = 0;
  501.     }
  502.     for ( x = 0; x < xw; x++) {
  503.         a = flag_now[ x];
  504.  
  505.         if ( a == 1) {    /* 変化点 */
  506.             if ( len >= 1023) len++;
  507.             write_length( len);
  508.             chain_flush();
  509.             len = 0;
  510.             write_color( x);
  511.             press_chain( x);
  512.         } else if ( a == 0) {
  513.             len++;
  514.         } else {
  515.             press_chain2( x);
  516.             if ( chain_pos == 1023) {
  517.                 write_length( 1023);
  518.                 chain_flush();
  519.                 len = 0;
  520.             }
  521.         }
  522.     }
  523. }
  524.  
  525. /*
  526.  * 行単位の圧縮
  527.  * 始めのと最終ラインの処理もする
  528.  */
  529. static long
  530. line_press( P2 *pp2, pix **line)
  531. {
  532.     if ( setjmp( jmp_env) != 0) return ( -1);
  533.     p2 = pp2;
  534.     para_out();
  535.  
  536.     if ( SHORT2short( pp2->header.depth) == 8) {
  537.         long i,j;
  538.  
  539.         xw = (xw + 1) / 2;
  540.         for ( i = j = 0; i < xw; i++) {
  541.             ushort hi = vram_next[ j++];
  542.             ushort low = vram_next[ j++];
  543.  
  544.             vram_next[ i] = hi * 256 + low;
  545.         }
  546.     }
  547.     
  548.     if ( ynow == 0) { /* 先頭ラインの時 */
  549.         long x;
  550.         pix cc = 0;
  551.  
  552.         /* フラグなどの初期化 */
  553.         memset( cache, 0, 256 * sizeof( cache[0]));
  554.         memset( cache_pos, 0, 8 * 8 * 8 * sizeof( cache_pos[0]));
  555.  
  556.         /* 変化点をマーク */
  557.         vram_next[ -1] = cc;
  558.         for ( x = 0; x < xw; x++) {
  559.             pix c = vram_next[ x];
  560.             if ( cc != c) {
  561.                 flag_next[ x] = 1;
  562.                 cc = c;
  563.             } else flag_next[ x] = 0;
  564.         }
  565.         fbufp = p2->fbuf;
  566.         n_fbuf = N_FBUF;
  567.         n_bit_buf = 8;
  568.         bit_buf = 0;
  569.         chain_pos = 0;
  570.         cache8_pos = 0;
  571.         len = 0;
  572.     } else { /* 2ライン目から実際にセーブをする。これは1ライン先のデータが必要だから */
  573.  
  574.         line_press2();
  575.     }
  576.     if ( ynow ==  ymax) {
  577.         /* 最後のラインの時は次のラインはもう無いので、これをセーブ */
  578.         ynow++;
  579.         para_in();
  580.         para_out();
  581.         if ( SHORT2short( pp2->header.depth) == 8) xw = (xw + 1) / 2;
  582.  
  583.         line_press2();
  584.     }
  585.     /* 次のデータを入れて欲しいライン (vram_prevは次回 vram_nextになる)*/
  586.     if ( line != NULL) *line = vram_prev;
  587.  
  588.     ynow++;
  589.  
  590.     if ( ynow - 1 < ymax) { /* 最終ライン(終り)でなければ */
  591.         para_in();    /* p2にパラメータ入れる(戻す) */
  592.         return ( ynow);
  593.     } else {    /* おわり */
  594.         para_in();    /* p2にパラメータ入れる(戻す) */
  595.         p2errno = 0;
  596.         if ( len >= 1023) len++;
  597.         write_length( len);
  598.         chain_flush();
  599.         fbuf_flush(); /* bitバッファを書き出して */
  600.         return ( -2);    /* おわり */
  601.     }
  602. }
  603.  
  604. /*
  605.  * 高速圧縮部の初期化
  606.  */
  607. long
  608. p2sf_sv_init( P2 *p2, pix **line)
  609. {
  610.     p2->ynow = 0;
  611.  
  612.     /* 色の記録関数のセット */
  613.     switch ( SHORT2short( p2->header.depth)) {
  614.     case 24:
  615.         p2->func = (pix (*)())write_color24;
  616.         break;
  617.     case 15:
  618.         p2->func = (pix (*)())write_color15;
  619.         break;
  620.     case 8:
  621.         p2->func = (pix (*)())write_color16;
  622.         break;
  623.     default:
  624.         p2errno= p2->errno = P2E_BADFORM;
  625.         break;
  626.     }
  627.  
  628.     /* 次ライン関数をセット */
  629.     p2->nextline = line_press;
  630.     if ( line != NULL) *line = p2->vram_next + 4;
  631.  
  632.     p2errno = 0;
  633.     seek_file( p2, p2->next_pos + SIZE_OF_BLK);
  634.     if ( p2errno == 0) return ( 0);
  635.     return ( -1);
  636. }
  637.  
  638. /***/
  639.  
  640. /*
  641.  * ベタの１ライン圧縮
  642.  */
  643. static long
  644. beta_line_press( P2 *pp2, pix **line)
  645. {
  646.     long i,xw,ymax;
  647.     uchar *p;
  648.     pix *pc;
  649.  
  650.     p2 = pp2;
  651.     ynow = p2->ynow;
  652.     xw = SHORT2short( p2->blk.x_wid);
  653.     ymax = SHORT2short( p2->blk.y_wid) - 1;
  654.  
  655.     if ( raw_beta == 0) { /* 他と同じ */
  656.         switch ( SHORT2short( p2->header.depth)) {
  657.         case 24:
  658.             pc = p2->vram_now;
  659.             p = (uchar *)p2->vram_prev;
  660.             for ( i = 0; i < xw; i++, pc++) {
  661.                 *p++ = *pc >> 16;
  662.                 *p++ = *pc >>  8;
  663.                 *p++ = *pc;
  664.             }
  665.             if ( write_file( p2, p2->vram_prev, xw * 3) != xw * 3) return ( -1);
  666.             break;
  667.  
  668.         case 15:
  669.             pc = p2->vram_now;
  670.             p = (uchar *)p2->vram_prev;
  671.             if ( memcmp( p2->blk.id, "P2BM", 4) == 0) {
  672.                 for ( i = 0; i < xw; i++, pc++) {
  673.                     *p++ = *pc >> 8;
  674.                     *p++ = *pc;
  675.                 }
  676.             } else {
  677.                 for ( i = 0; i < xw; i++, pc++) {
  678.                     *p++ = *pc;
  679.                     *p++ = *pc >> 8;
  680.                 }
  681.             }
  682.             if ( write_file( p2, p2->vram_prev, xw * 2) != xw * 2) return ( -1);
  683.             break;
  684.  
  685.         case 8:
  686.             pc = p2->vram_now;
  687.             p = (uchar *)p2->vram_prev;
  688.             for ( i = 0; i < xw; i++) {
  689.                 *p++ = *pc++;
  690.             }
  691.             if ( write_file( p2, p2->vram_prev, xw) != xw) return ( -1);
  692.             break;
  693.         }
  694.         if ( line != NULL) *line = p2->vram_now;
  695.     } else { /* ベタ */
  696.         switch ( SHORT2short( p2->header.depth)) {
  697.         case 24:
  698.             if ( write_file( p2, p2->vram_now, xw * 3) != xw * 3) return ( -1);
  699.             break;
  700.         case 15:
  701.             if ( write_file( p2, p2->vram_now, xw * 2) != xw * 2) return ( -1);
  702.             break;
  703.         case 8:
  704.             if ( write_file( p2, p2->vram_now, xw) != xw) return ( -1);
  705.             break;
  706.         }
  707.         *line = p2->vram_now;
  708.     }
  709.     p2->ynow++;
  710.     if ( p2->ynow > ymax) return ( -2);
  711.     return ( p2->ynow);
  712. }
  713.  
  714. /*
  715.  * ベタ圧縮の初期化
  716.  */
  717. long
  718. p2b_sv_init( P2 *p2, pix **line)
  719. {
  720.     p2->ynow = 0;
  721.  
  722.     *line = p2->vram_now;
  723.     p2->nextline = beta_line_press;
  724.     p2errno = 0;
  725.     seek_file( p2, p2->next_pos + SIZE_OF_BLK);
  726.     if ( p2errno == 0) return ( 0);
  727.     return ( -1);
  728. }
  729.  
  730. /* eof */
  731.  
  732.